home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / libgutil / sgiobjgl.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  12KB  |  430 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  *    sgiobjgl -
  19.  *        A simple object format - graphics support.
  20.  *
  21.  *            Paul Haeberli - 1990
  22.  */
  23. #include "stdio.h"
  24. #include "gl.h"
  25. #include "device.h"
  26. #include "sgiobj.h"
  27. #include "spin.h"
  28.  
  29. static randcolor();
  30.  
  31. #define BYTEOFF(v)    (sizeof(long)*(v))
  32.  
  33. static trilines(verts)
  34. float *verts[3];
  35. {
  36.     bgnclosedline();
  37.     v3f(verts[0]+OFFSET_POINT);
  38.     v3f(verts[1]+OFFSET_POINT);
  39.     v3f(verts[2]+OFFSET_POINT);
  40.     endclosedline();
  41. }
  42.  
  43. drawsgiobj(obj,how)
  44. sgiobj *obj;
  45. int how;
  46. {
  47.     long npolys;
  48.     long *data;
  49.     char *vertdata, *avert;
  50.     int vertlongs, nverts;
  51.  
  52.     data = obj->data;
  53.     if(obj->objtype == OBJ_QUADLIST) {
  54.     npolys = (obj->nlongs/PNTLONGS)/4;
  55.     switch(how) {
  56.         case DRAW_LINES:
  57.         while(npolys--) {
  58.             bgnclosedline();
  59.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  60.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  61.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  62.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  63.             endclosedline();
  64.             data += PNTLONGS*4;
  65.         }
  66.         break;
  67.         case DRAW_POINTS:
  68.         while(npolys--) {
  69.             bgntmesh();
  70.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  71.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  72.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  73.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  74.             endtmesh();
  75.             data += PNTLONGS*4;
  76.         }
  77.         break;
  78.         case DRAW_POINTS|DRAW_NORMALS:
  79.         while(npolys--) {
  80.             bgntmesh();
  81.             n3f((float*)&data[(PNTLONGS*0)+OFFSET_NORMAL]);
  82.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  83.             n3f((float*)&data[(PNTLONGS*1)+OFFSET_NORMAL]);
  84.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  85.             n3f((float*)&data[(PNTLONGS*3)+OFFSET_NORMAL]);
  86.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  87.             n3f((float*)&data[(PNTLONGS*2)+OFFSET_NORMAL]);
  88.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  89.             endtmesh();
  90.             data += PNTLONGS*4;
  91.         }
  92.         break;
  93.         case DRAW_POINTS|DRAW_UVS:
  94.         while(npolys--) {
  95.             bgntmesh();
  96.             myt2f((float*)&data[(PNTLONGS*0)+OFFSET_UVS]);
  97.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  98.             myt2f((float*)&data[(PNTLONGS*1)+OFFSET_UVS]);
  99.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  100.             myt2f((float*)&data[(PNTLONGS*3)+OFFSET_UVS]);
  101.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  102.             myt2f((float*)&data[(PNTLONGS*2)+OFFSET_UVS]);
  103.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  104.             endtmesh();
  105.             data += PNTLONGS*4;
  106.         }
  107.         break;
  108.         case DRAW_POINTS|DRAW_UVS|DRAW_NORMALS:
  109.         while(npolys--) {
  110.             bgntmesh();
  111.             myt2f((float*)&data[(PNTLONGS*0)+OFFSET_UVS]);
  112.             n3f((float*)&data[(PNTLONGS*0)+OFFSET_NORMAL]);
  113.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  114.             myt2f((float*)&data[(PNTLONGS*1)+OFFSET_UVS]);
  115.             n3f((float*)&data[(PNTLONGS*1)+OFFSET_NORMAL]);
  116.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  117.             myt2f((float*)&data[(PNTLONGS*3)+OFFSET_UVS]);
  118.             n3f((float*)&data[(PNTLONGS*3)+OFFSET_NORMAL]);
  119.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  120.             myt2f((float*)&data[(PNTLONGS*2)+OFFSET_UVS]);
  121.             n3f((float*)&data[(PNTLONGS*2)+OFFSET_NORMAL]);
  122.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  123.             endtmesh();
  124.             data += PNTLONGS*4;
  125.         }
  126.         break;
  127.         case DRAW_POINTS|DRAW_COLORS:
  128.         while(npolys--) {
  129.             bgntmesh();
  130.             c3f((float*)&data[(PNTLONGS*0)+OFFSET_COLOR]);
  131.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  132.             c3f((float*)&data[(PNTLONGS*1)+OFFSET_COLOR]);
  133.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  134.             c3f((float*)&data[(PNTLONGS*3)+OFFSET_COLOR]);
  135.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  136.             c3f((float*)&data[(PNTLONGS*2)+OFFSET_COLOR]);
  137.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  138.             endtmesh();
  139.             data += PNTLONGS*4;
  140.         }
  141.         break;
  142.         case DRAW_POINTS|DRAW_COLORS|DRAW_NORMALS:
  143.         while(npolys--) {
  144.             bgntmesh();
  145.             c3f((float*)&data[(PNTLONGS*0)+OFFSET_COLOR]);
  146.             n3f((float*)&data[(PNTLONGS*0)+OFFSET_NORMAL]);
  147.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  148.             c3f((float*)&data[(PNTLONGS*1)+OFFSET_COLOR]);
  149.             n3f((float*)&data[(PNTLONGS*1)+OFFSET_NORMAL]);
  150.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  151.             c3f((float*)&data[(PNTLONGS*3)+OFFSET_COLOR]);
  152.             n3f((float*)&data[(PNTLONGS*3)+OFFSET_NORMAL]);
  153.             v3f((float*)&data[(PNTLONGS*3)+OFFSET_POINT]);
  154.             c3f((float*)&data[(PNTLONGS*2)+OFFSET_COLOR]);
  155.             n3f((float*)&data[(PNTLONGS*2)+OFFSET_NORMAL]);
  156.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  157.             endtmesh();
  158.             data += PNTLONGS*4;
  159.         }
  160.         break;
  161.     }
  162.     } else if(obj->objtype == OBJ_TRILIST) {
  163.     npolys = (obj->nlongs/PNTLONGS)/3;
  164.     switch(how) {
  165.         case DRAW_LINES:
  166.         while(npolys--) {
  167.             bgnclosedline();
  168.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  169.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  170.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  171.             endclosedline();
  172.             data += PNTLONGS*3;
  173.         }
  174.         break;
  175.         case DRAW_POINTS:
  176.         while(npolys--) {
  177.             bgntmesh();
  178.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  179.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  180.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  181.             endtmesh();
  182.             data += PNTLONGS*3;
  183.         }
  184.         break;
  185.         case DRAW_POINTS|DRAW_NORMALS:
  186.         while(npolys--) {
  187.             bgntmesh();
  188.             n3f((float*)&data[(PNTLONGS*0)+OFFSET_NORMAL]);
  189.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  190.             n3f((float*)&data[(PNTLONGS*1)+OFFSET_NORMAL]);
  191.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  192.             n3f((float*)&data[(PNTLONGS*2)+OFFSET_NORMAL]);
  193.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  194.             endtmesh();
  195.             data += PNTLONGS*3;
  196.         }
  197.         break;
  198.         case DRAW_POINTS|DRAW_UVS:
  199.         while(npolys--) {
  200.             bgntmesh();
  201.             myt2f((float*)&data[(PNTLONGS*0)+OFFSET_UVS]);
  202.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  203.             myt2f((float*)(float*)&data[(PNTLONGS*1)+OFFSET_UVS]);
  204.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  205.             myt2f((float*)&data[(PNTLONGS*2)+OFFSET_UVS]);
  206.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  207.             endtmesh();
  208.             data += PNTLONGS*3;
  209.         }
  210.         break;
  211.         case DRAW_POINTS|DRAW_UVS|DRAW_NORMALS:
  212.         while(npolys--) {
  213.             bgntmesh();
  214.             n3f((float*)&data[(PNTLONGS*0)+OFFSET_NORMAL]);
  215.             myt2f((float*)&data[(PNTLONGS*0)+OFFSET_UVS]);
  216.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  217.             n3f((float*)&data[(PNTLONGS*1)+OFFSET_NORMAL]);
  218.             myt2f((float*)&data[(PNTLONGS*1)+OFFSET_UVS]);
  219.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  220.             n3f((float*)&data[(PNTLONGS*2)+OFFSET_NORMAL]);
  221.             myt2f((float*)&data[(PNTLONGS*2)+OFFSET_UVS]);
  222.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  223.             endtmesh();
  224.             data += PNTLONGS*3;
  225.         }
  226.         break;
  227.         case DRAW_POINTS|DRAW_COLORS:
  228.         while(npolys--) {
  229.             bgntmesh();
  230.             c3f((float*)&data[(PNTLONGS*0)+OFFSET_COLOR]);
  231.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  232.             c3f((float*)&data[(PNTLONGS*1)+OFFSET_COLOR]);
  233.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  234.             c3f((float*)&data[(PNTLONGS*2)+OFFSET_COLOR]);
  235.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  236.             endtmesh();
  237.             data += PNTLONGS*3;
  238.         }
  239.         break;
  240.         case DRAW_POINTS|DRAW_COLORS|DRAW_NORMALS:
  241.         while(npolys--) {
  242.             bgntmesh();
  243.             c3f((float*)&data[(PNTLONGS*0)+OFFSET_COLOR]);
  244.             n3f((float*)&data[(PNTLONGS*0)+OFFSET_NORMAL]);
  245.             v3f((float*)&data[(PNTLONGS*0)+OFFSET_POINT]);
  246.             c3f((float*)&data[(PNTLONGS*1)+OFFSET_COLOR]);
  247.             n3f((float*)&data[(PNTLONGS*1)+OFFSET_NORMAL]);
  248.             v3f((float*)&data[(PNTLONGS*1)+OFFSET_POINT]);
  249.             c3f((float*)&data[(PNTLONGS*2)+OFFSET_COLOR]);
  250.             n3f((float*)&data[(PNTLONGS*2)+OFFSET_NORMAL]);
  251.             v3f((float*)&data[(PNTLONGS*2)+OFFSET_POINT]);
  252.             endtmesh();
  253.             data += PNTLONGS*3;
  254.         }
  255.         break;
  256.     }
  257.     } else if(obj->objtype == OBJ_TRIMESH) {
  258.     if(how == DRAW_LINES)
  259.         applytomeshtris(obj,trilines);
  260.     else {
  261.         vertlongs = *data++;
  262.         vertdata = (char *)data;
  263.         data += vertlongs;
  264.         while(1) {
  265.         switch(*data++) {
  266.             case OP_BGNTMESH:
  267.             bgntmesh();
  268.             break;
  269.             case OP_SWAPTMESH:
  270.             swaptmesh();
  271.             break;
  272.             case OP_ENDBGNTMESH:
  273.             endtmesh();
  274.             bgntmesh();
  275.             break;
  276.             case OP_ENDTMESH:
  277.             endtmesh();
  278.             return;
  279.             default:
  280.             fprintf(stderr,"drawsgiobj: bad tmesh op %d\n",*data);
  281.             exit(1);
  282.         }
  283.         nverts = *data++;
  284.         switch(how) {
  285.             case DRAW_POINTS:
  286.             while(nverts--) {
  287.                 avert = vertdata + *data++;
  288.                 v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  289.             }
  290.             break;
  291.             case DRAW_POINTS|DRAW_NORMALS:
  292.             while(nverts--) {
  293.                 avert = vertdata + *data++;
  294.                 n3f((float*)(avert+BYTEOFF(OFFSET_NORMAL)));
  295.                 v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  296.             }
  297.             break;
  298.             case DRAW_POINTS|DRAW_UVS:
  299.             while(nverts--) {
  300.                 avert = vertdata + *data++;
  301.                 myt2f((float*)(avert+BYTEOFF(OFFSET_UVS)));
  302.                 v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  303.             }
  304.             break;
  305.             case DRAW_POINTS|DRAW_UVS|DRAW_NORMALS:
  306.             while(nverts--) {
  307.                 avert = vertdata + *data++;
  308.                 myt2f((float*)(avert+BYTEOFF(OFFSET_UVS)));
  309.                 n3f((float*)(avert+BYTEOFF(OFFSET_NORMAL)));
  310.                 v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  311.             }
  312.             break;
  313.             case DRAW_POINTS|DRAW_COLORS:
  314.             while(nverts--) {
  315.                 avert = vertdata + *data++;
  316.                 c3f((float*)(avert+BYTEOFF(OFFSET_COLOR)));
  317.                 v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  318.             }
  319.             break;
  320.             case DRAW_POINTS|DRAW_COLORS|DRAW_NORMALS:
  321.             while(nverts--) {
  322.                 avert = vertdata + *data++;
  323.                 c3f((float*)(avert+BYTEOFF(OFFSET_COLOR)));
  324.                 n3f((float*)(avert+BYTEOFF(OFFSET_NORMAL)));
  325.                 v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  326.             }
  327.         }
  328.         }
  329.     }
  330.     } else {
  331.     fprintf(stderr,"drawsgiobj: bad object type %d\n",obj->objtype);
  332.     exit(1);
  333.     }
  334. }
  335.  
  336. /* 
  337.  *    show normals on an sgi object
  338.  *
  339.  *
  340.  */
  341. #define NSCALE 0.020
  342.  
  343. static drawnorm(p)
  344. float *p;
  345. {
  346.     float p2[3];
  347.  
  348.     p2[0] = p[OFFSET_POINT+0]+NSCALE*p[OFFSET_NORMAL+0];
  349.     p2[1] = p[OFFSET_POINT+1]+NSCALE*p[OFFSET_NORMAL+1];
  350.     p2[2] = p[OFFSET_POINT+2]+NSCALE*p[OFFSET_NORMAL+2];
  351.     bgnline();
  352.     v3f(p+OFFSET_POINT);
  353.     v3f(p2);
  354.     endline();
  355. }
  356.  
  357. drawsgiobjnorms(obj)
  358. sgiobj *obj;
  359. {
  360.     applytoverts(obj,drawnorm);
  361. }
  362.  
  363. /* 
  364.  *    show tri meshes in an sgi object
  365.  *
  366.  *
  367.  */
  368. drawsgiobjmeshs(obj)
  369. sgiobj *obj;
  370. {
  371.     long npolys;
  372.     long *data;
  373.     char *vertdata, *avert;
  374.     int vertlongs, nverts;
  375.  
  376.     data = obj->data;
  377.     if(obj->objtype == OBJ_QUADLIST) {
  378.     fprintf(stderr,"drawsgiobjtmesh: can't draw QUADLISTS\n");
  379.     return;
  380.     } else if(obj->objtype == OBJ_TRILIST) {
  381.     fprintf(stderr,"drawsgiobjtmesh: can't draw TRILISTS\n");
  382.     return;
  383.     } else if(obj->objtype == OBJ_TRIMESH) {
  384.     vertlongs = *data++;
  385.     vertdata = (char *)data;
  386.     data += vertlongs;
  387.     while(1) {
  388.         switch(*data++) {
  389.         case OP_BGNTMESH:
  390.             randcolor();
  391.             bgntmesh();
  392.             break;
  393.         case OP_SWAPTMESH:
  394.             swaptmesh();
  395.             break;
  396.         case OP_ENDBGNTMESH:
  397.             endtmesh();
  398.             randcolor();
  399.             bgntmesh();
  400.             break;
  401.         case OP_ENDTMESH:
  402.             endtmesh();
  403.             return;
  404.         default:
  405.             fprintf(stderr,"drawsgiobjtmesh: bad tmesh op %d\n",*data);
  406.             exit(1);
  407.         }
  408.         nverts = *data++;
  409.         while(nverts--) {
  410.         avert = vertdata + *data++;
  411.         n3f((float*)(avert+BYTEOFF(OFFSET_NORMAL)));
  412.         v3f((float*)(avert+BYTEOFF(OFFSET_POINT)));
  413.         }
  414.     }
  415.     } else {
  416.     fprintf(stderr,"drawsgiobjtmesh: bad object type %d\n",obj->objtype);
  417.     exit(1);
  418.     }
  419. }
  420.  
  421. static randcolor()
  422. {
  423.     int r, g, b;
  424.  
  425.     r = rand()&0xff;
  426.     g = rand()&0xff;
  427.     b = rand()&0xff;
  428.     cpack((b<<16)+(g<<8)+(r<<0));
  429. }
  430.